home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / video / fly8111-.000 / fly8111- / fly8 / menus.c < prev    next >
C/C++ Source or Header  |  1979-12-31  |  16KB  |  886 lines
  1. /* --------------------------------- menus.c -------------------------------- */
  2.  
  3. /* This is part of the flight simulator 'fly8'.
  4.  * Author: Eyal Lebedinsky (eyal@ise.canberra.edu.au).
  5. */
  6.  
  7. /* Menus.
  8. */
  9.  
  10. #include "plane.h"
  11.  
  12.  
  13. static MENU FAR MenuYN[] = {
  14.     {'y', "Yes"},
  15.     {'n', "No"},
  16. {'\0', 0}};
  17.  
  18. /* Select info level
  19. */
  20.  
  21. static MENU FAR MenuInfo[] = {
  22.     {'0', "off"},
  23.     {'1', "on"},
  24.     {'2', "none"},        /* keep these in this exact order! */
  25.     {'3', "timing"},
  26.     {'4', "stats"},
  27.     {'5', "game"},
  28. {'\0', 0}};
  29.  
  30. LOCAL_FUNC int NEAR
  31. menu_info (void)
  32. {
  33.     int    sel;
  34.  
  35.     sel = menu_open (MenuInfo, !(st.flags1 & SF_INFO));
  36.  
  37.     switch (sel) {
  38.     case MENU_ABORTED:
  39.     case MENU_FAILED:
  40.         break;
  41.     case 0:
  42.         st.flags1 &= ~SF_INFO;
  43.         break;
  44.     case 1:
  45.         st.flags1 |= SF_INFO;
  46.         break;
  47.     default:
  48.         st.info = sel - 2;
  49.         st.flags1 |= SF_INFO;
  50.         break;
  51.     }
  52.     if (MENU_FAILED != sel)
  53.         menu_close ();
  54.  
  55.     return (0);
  56. }
  57.  
  58. /* Remove all objects of type 'name'.
  59. */
  60.  
  61. LOCAL_FUNC void NEAR
  62. clear_object (int name)
  63. {
  64.     OBJECT    *p;
  65.  
  66.     for (p = CO; p;) {
  67.         if (p->name == name) {
  68.             if (O_PLANE != name ||
  69.                 (EE(p)->flags & PF_AUTO))
  70.                 p->flags |= F_DEL|F_MOD;
  71.         }
  72.         p = p->next;
  73.     }
  74. }
  75.  
  76. static MENU FAR MenuEmit[] = {
  77.     {'t', "target"},    /*  0 */
  78.     {'T', "  del"},     /*  1 */
  79.     {'g', "gtarget"},    /*  2 */
  80.     {'G', "  del"},     /*  3 */
  81.     {'b', "box"},        /*  4 */
  82.     {'B', "  del"},     /*  5 */
  83.     {'-', "dell tgts"},    /*  6 */
  84.     {'d', "drone"},     /*  7 */
  85.     {'D', "  del"},     /*  8 */
  86.     {'y', "drones"},    /*  9 */
  87.     {'z', "killers"},    /* 10 */
  88.     {'r', "game"},        /* 11 */
  89. {'\0', 0}};
  90.  
  91. LOCAL_FUNC int NEAR
  92. menu_emit (void)
  93. {
  94.     int    sel, quit, i;
  95.     char    msg[80], prompt[80];
  96.     OBJECT    *p;
  97.  
  98.     sel = 0;
  99.     for (quit = 0; !quit;) {
  100.         sel = menu_open (MenuEmit, sel);
  101.         switch (sel) {
  102.         default:
  103.             quit = 1;
  104.             break;
  105.         case 0:
  106.             create_object (O_TARGET, 1);
  107.             break;
  108.         case 1:
  109.             clear_object (O_TARGET);
  110.             st.flags1 &= ~SF_TESTING;
  111.             break;
  112.         case 2:
  113.             create_object (O_GTARGET, 1);
  114.             break;
  115.         case 3:
  116.             clear_object (O_GTARGET);
  117.             st.flags1 &= ~SF_TESTING;
  118.             break;
  119.         case 4:
  120.             create_object (O_BOX, 1);
  121.             break;
  122.         case 5:
  123.             clear_object (O_BOX);
  124.             break;
  125.         case 6:
  126.             clear_object (O_TARGET);
  127.             clear_object (O_GTARGET);
  128.             clear_object (O_BOX);
  129.             st.flags1 &= ~SF_TESTING;
  130.             break;
  131.         case 7:
  132.             emit_drone ();
  133.             break;
  134.         case 8:
  135.             clear_object (O_PLANE);
  136.             st.drones = 0;         /* no more drones */
  137.             break;
  138.         case 9:
  139.             for (;;) {
  140.                 sprintf (prompt, "planes number(%d)",
  141.                     (int)st.drones);
  142.                 sprintf (msg, "%d", (int)st.drones);
  143.                 edit_str (prompt, msg, sizeof (msg));
  144.                 if ('\0' == msg[0])
  145.                     break;
  146.                 if (1 == sscanf (msg, "%u", &i) && i >= 0) {
  147.                     st.drones = i;
  148.                     break;
  149.                 }
  150.             }
  151.             break;
  152.         case 10:
  153.             for (;;) {
  154.                 sprintf (prompt, "killers number(%d)",
  155.                     (int)st.killers);
  156.                 sprintf (msg, "%d", (int)st.killers);
  157.                 edit_str (prompt, msg, sizeof (msg));
  158.                 if ('\0' == msg[0])
  159.                     break;
  160.                 if (1 == sscanf (msg, "%u", &i) &&
  161.                     i >= 0 && i <= st.drones) {
  162.                     st.killers = i;
  163.                     break;
  164.                 }
  165.             }
  166.             break;
  167.         case 11:
  168.             st.info = 3;            /* show time & count */
  169.             st.flags1 |= SF_TESTING|SF_INFO;
  170.             st.ntargets = 10;
  171.             st.nbullets = 0;
  172.             st.test_start = st.present;
  173.             for (p = CO; p;) {    /* kill boxes and targets */
  174.                 if (p->name == O_GTARGET || p->name == O_BOX ||
  175.                     p->name == O_TARGET || p->name == O_M61 ||
  176.                     p->name == O_MK82)
  177.                     p->flags |= F_DEL|F_MOD;
  178.                 p = p->next;
  179.             }
  180.             st.mscore = 0;
  181.             for (i = 0; i < st.ntargets; ++i) {
  182.                 if (!create_object (O_TARGET, 1))
  183.                     break;
  184.                 /* 15 seconds + 25 bullets */
  185.                 st.mscore += 15*10 + 25*2;
  186.             }
  187.             (*CC->pointer->control->Key)(CC->pointer, KF_ORIGIN);
  188.             (*CC->pointer->control->Key)(CC->pointer, KF_POWER_0);
  189.             (*CC->pointer->control->Key)(CC->pointer, KF_LEVEL);
  190.             break;
  191.         }
  192.         if (MENU_FAILED != sel)
  193.             menu_close ();
  194.     }
  195.  
  196.     return (0);
  197. }
  198.  
  199. /* debug menu
  200. */
  201.  
  202. static MENU FAR MenuDebug[] = {
  203.     {'0', "off"},
  204.     {'1', "on"},
  205.     {'2', "toggle"},
  206.     {'d', "debug"},        /*  3 */
  207.     {'w', "gp w"},         /*  4 */
  208.     {'x', "gp x"},         /*  5 */
  209.     {'y', "gp y"},        /*  6 */
  210.     {'z', "gp z"},         /*  7 */
  211. {'\0', 0}};
  212.  
  213. LOCAL_FUNC int NEAR
  214. menu_debug (void)
  215. {
  216.     int    sel, quit;
  217.  
  218.     SetOption (0, 2);
  219.     sel = 3;
  220.     for (quit = 0; !quit;) {
  221.         sel = menu_open (MenuDebug, sel);
  222.         switch (sel) {
  223.         default:
  224.             quit = 1;
  225.             break;
  226.         case 0:
  227.         case 1:
  228.         case 2:
  229.             SetOption (0, sel);
  230.             break;
  231.         case 3:
  232.             SetOption (&st.flags, SF_DEBUG);
  233.             break;
  234.         case 4:
  235.             SetOption (&st.debug, DF_GPW);
  236.             break;
  237.         case 5:
  238.             SetOption (&st.debug, DF_GPX);
  239.             break;
  240.         case 6:
  241.             SetOption (&st.debug, DF_GPY);
  242.             break;
  243.         case 7:
  244.             SetOption (&st.debug, DF_GPZ);
  245.             break;
  246.         }
  247.         if (MENU_FAILED != sel)
  248.             menu_close ();
  249.     }
  250.     return (0);
  251. }
  252.  
  253. /* options menu
  254. */
  255.  
  256. static MENU FAR MenuOpts[] = {
  257.     {'0', "off"},
  258.     {'1', "on"},
  259.     {'2', "toggle"},
  260.     {'v', "Version"},    /*  3 */
  261.     {'s', "Smoke"},     /*  4 */
  262.     {'f', "Font"},        /*  5 */
  263.     {'c', "Colors"},    /*  6 */
  264.     {'m', "Modes"},     /*  7 */
  265.     {'k', "Sky"},        /*  8 */
  266.     {'g', "Gravity"},    /*  9 */
  267.     {'b', "Play Blues"},    /* 10 */
  268.     {'V', "Verbose"},    /* 11 */
  269.     {'n', "Net Stats"},    /* 12 */
  270.     {'l', "Limited"},    /* 13 */
  271.     {'N', "no stall"},    /* 14 */
  272.     {'p', "paused msg"},    /* 15 */
  273.     {'w', "win ident"},    /* 16 */
  274. {'\0', 0}};
  275.  
  276. LOCAL_FUNC int NEAR
  277. menu_opts (void)
  278. {
  279.     int    sel, quit;
  280.  
  281.     SetOption (0, 2);
  282.     sel = 0;
  283.     for (quit = 0; !quit;) {
  284.         sel = menu_open (MenuOpts, sel);
  285.         switch (sel) {
  286.         default:
  287.             quit = 1;
  288.             break;
  289.         case 0:
  290.         case 1:
  291.         case 2:
  292.             SetOption (0, sel);
  293.             break;
  294.         case 3:
  295.             welcome (0);
  296.             MsgPrintf (50, "%s at %dx%d", Gr->name,
  297.                 CS->device->sizex, CS->device->sizey);
  298.             break;
  299.         case 4:
  300.             SetOption (&st.flags1, SF_SMOKE);
  301.             break;
  302.         case 5:
  303.             set_lists (SF_FONT);
  304.             break;
  305.         case 6:
  306.             set_lists (SF_COLORS);
  307.             break;
  308.         case 7:
  309.             set_lists (SF_MODES);
  310.             break;
  311.         case 8:
  312.             SetOption (&st.flags, SF_SKY);
  313.             if (st.flags & SF_SKY)
  314.                 sky_init ();
  315.             else
  316.                 sky_term ();
  317.             break;
  318.         case 9:
  319.             SetOption (&st.flags1, SF_USEG);
  320.             break;
  321.         case 10:
  322.             if (st.quiet)
  323.                 Snd->List (TnBlues, SND_ON);
  324.             break;
  325.         case 11:
  326.             SetOption (&st.flags, SF_VERBOSE);
  327.             break;
  328.         case 12:
  329.             set_lists (SF_NET);
  330.             break;
  331.         case 13:
  332.             if (IS_PLANE(CV))
  333.                 SetOption (&EE(CV)->flags, PF_LIMITED);
  334.             break;
  335.         case 14:
  336.             if (IS_PLANE(CV))
  337.                 SetOption (&EE(CV)->flags, PF_NOSTALL);
  338.             break;
  339.         case 15:
  340.             SetOption (&st.flags, SF_PAUSEMSG);
  341.             break;
  342.         case 16:
  343.             SetOption (&st.flags1, SF_WIDENT);
  344.             break;
  345.         }
  346.         if (MENU_FAILED != sel)
  347.             menu_close ();
  348.     }
  349.     return (0);
  350. }
  351.  
  352. /* net menu
  353. */
  354.  
  355. LOCAL_FUNC int FAR
  356. match_player (PLAYER *pl, char *name, int nlen, char *team, int tlen)
  357. {
  358.     if (name && strnicmp (pl->name, name, nlen))
  359.         return (0);
  360.     if (team && strnicmp (pl->team, team, tlen))
  361.         return (0);
  362.     return (1);
  363. }
  364.  
  365. LOCAL_FUNC PLAYER * NEAR
  366. match_players (int mode, char *fullname)
  367. {
  368.     char    *name, *team;
  369.     int     nlen, tlen;
  370.     PLAYER  *pl;
  371.  
  372.     if (T(team = strchr (fullname, ':'))) {
  373.         nlen = (int)(team - fullname);
  374.         if (!nlen)
  375.             name = 0;
  376.         else
  377.             name = fullname;
  378.         ++team;
  379.         tlen = strlen (team);
  380.         if (!tlen)
  381.             team = 0;
  382.     } else {
  383.         tlen = 0;
  384.         name = fullname;
  385.         nlen = strlen (name);
  386.         if (!nlen)
  387.             name = 0;
  388.     }
  389.     for (pl = 0; T(pl = player_next (pl));) {
  390.         if ((pl->flags & mode) &&
  391.             match_player (pl, name, nlen, team, tlen))
  392.             return (pl);
  393.     }
  394.     return (0);
  395. }
  396.  
  397. /* returns: selected player, 0 (abort), no_players, all_team or all_players.
  398. */
  399. LOCAL_FUNC PLAYER * NEAR
  400. choose_player (int mode)
  401. {
  402.     int     i;
  403.     PLAYER  *pl;
  404.     char    msg[2*LNAME];
  405.  
  406.     for (;;) {
  407.         for (i = 0, pl = 0; T(pl = player_next (pl));) {
  408.             if (pl->flags & mode) {
  409.                 ++i;
  410.                 MsgWPrintf (100, "%s:%s", pl->name, pl->team);
  411.             }
  412.         }
  413.         if (!i)
  414.             return (st.no_players);
  415.         msg[0] = '\0';
  416.         edit_str ("choose player", msg, sizeof (msg));
  417.         if ('*' == msg[0])
  418.             return (st.all_players);
  419.         if ('+' == msg[0])
  420.             return (st.all_team);
  421.         if ('\0' == msg[0])
  422.             return (0);
  423.         if (T(pl = match_players (mode, msg)))
  424.             return (pl);
  425.     }
  426. }
  427.  
  428. static MENU FAR MenuNet[] = {
  429.     {'p', "ping"},      /*  0 */
  430.     {'y', "play"},      /*  1 */
  431.     {'q', "quit"},      /*  2 */
  432.     {'m', "message"},       /*  3 */
  433.     {'a', "accept"},    /*  4 */
  434.     {'d', "decline"},       /*  5 */
  435.     {'A', "auto accept"},   /*  6 */
  436.     {'D', "auto decline"},  /*  7 */
  437.     {'r', "manual reply"},  /*  8 */
  438.     {'c', "auto connect"},  /*  9 */
  439. {'\0', 0}};
  440.  
  441. LOCAL_FUNC int NEAR
  442. menu_net (void)
  443. {
  444.     int     sel, i;
  445.     char    msg[80];
  446.     PLAYER  *pl, *pl1;
  447.  
  448. /* If no net, still go through the menu. This makes macros predictable.
  449. */
  450.     if (!(st.network & NET_ON))
  451.         MsgPrintf (50, "no net");
  452.  
  453.     sel = menu_open (MenuNet, 0);
  454.  
  455.     if (!(st.network & NET_ON)) {
  456.         MsgPrintf (50, "no net");
  457.         sel = MENU_ABORTED;
  458.     }
  459.  
  460.     switch (sel) {
  461.     default:
  462.         break;
  463.     case 0:         /* ping */
  464.         remote_ping ();
  465.         break;
  466.     case 1:         /* play */
  467.         pl = choose_player (~PL_PLAYING);
  468.         if (pl == st.no_players)
  469.             MsgPrintf (50, "no players");
  470.         else if (pl == st.all_players || pl == st.all_team) {
  471.             for (pl1 = 0; T(pl1 = player_next (pl1));) {
  472.                 if (!(pl1->flags & PL_PLAYING)) {
  473.                     if (pl == st.all_team &&
  474.                             stricmp (pl1->team,
  475.                             st.teamname))
  476.                         continue;
  477.                     remote_request (pl1);
  478.                 }
  479.             }
  480.         } else if (pl)
  481.             remote_request (pl);
  482.         break;
  483.     case 2:         /* quit */
  484.         pl = choose_player (PL_PLAYING);
  485.         if (pl == st.no_players)
  486.             MsgPrintf (50, "no players");
  487.         else if (pl == st.all_players) {
  488.             MsgPrintf (50, "Quitting all");
  489.             remote_noplay (st.all_active);
  490.             players_remove (st.all_known);
  491.         } else if (pl == st.all_team) {
  492.             MsgPrintf (50, "Quitting team");
  493.             remote_noplay (st.all_team);
  494.             players_remove (st.all_team);
  495.         } else if (pl) {
  496.             MsgPrintf (50, "Quitting %s:%s", pl->name, pl->team);
  497.             remote_noplay (pl);
  498.             player_remove (pl);
  499.         }
  500.         break;
  501.     case 3:         /* message */
  502.         pl = choose_player (~0);
  503.         if (pl == st.no_players)
  504.             MsgPrintf (50, "no players");
  505.         else if (pl) {
  506.             msg[0] = '\0';
  507.             edit_str ("message text", msg, sizeof (msg));
  508.             if (pl == st.all_players) {
  509.                 remote_time (st.all_active);
  510.                 remote_msg (msg, st.all_active);
  511.             } else if (pl == st.all_team) {
  512.                 remote_time (st.all_team);
  513.                 remote_msg (msg, st.all_team);
  514.             } else {
  515.                 remote_time (pl);
  516.                 remote_msg (msg, pl);
  517.             }
  518.         }
  519.         break;
  520.     case 4:         /* accept */
  521.     case 5:         /* decline */
  522.         i = (4 == sel);
  523.         pl = choose_player (PL_PENDBOSS);
  524.         if (pl == st.no_players)
  525.             MsgPrintf (50, "no players");
  526.         else if (pl == st.all_players || pl == st.all_team) {
  527.             for (pl1 = 0; T(pl1 = player_next (pl1));) {
  528.                 if (pl1->flags & PL_PENDBOSS) {
  529.                     if (pl == st.all_team &&
  530.                             stricmp (pl1->team,
  531.                                 st.teamname))
  532.                         continue;
  533.                     remote_reply (pl1, i);
  534.                 }
  535.             }
  536.         } else if (pl)
  537.             remote_reply (pl, i);
  538.         break;
  539.     case 6:         /* auto accept */
  540.         st.network &= ~NET_AUTOREPLY;
  541.         st.network |= NET_AUTOACCEPT;
  542.         break;
  543.     case 7:         /* auto decline */
  544.         st.network &= ~NET_AUTOREPLY;
  545.         st.network |= NET_AUTODECLINE;
  546.         break;
  547.     case 8:         /* manual reply */
  548.         st.network &= ~NET_AUTOREPLY;
  549.         break;
  550.     case 9:         /* auto connect */
  551.         st.network &= ~NET_AUTOREPLY;
  552.         st.network |= (NET_AUTOACCEPT|NET_AUTOCONNECT);
  553.         break;
  554.     }
  555.     if (MENU_FAILED != sel)
  556.         menu_close ();
  557.  
  558.     return (0);
  559. }
  560.  
  561. /* stereo menu
  562. */
  563.  
  564. static MENU FAR MenuStr[] = {
  565.     {'0', "off"},
  566.     {'1', "on"},
  567.     {'2', "toggle"},
  568.     {'m', "Mono"},      /*  3 */
  569.     {'s', "S'Scopic"},      /*  4 */
  570.     {'b', "RedBlue"},       /*  5 */
  571.     {'a', "Alternate"},     /*  6 */
  572.     {'r', "Reverse"},       /*  7 */
  573.     {'p', "Paralax"},       /*  8 */
  574. {'\0', 0}};
  575.  
  576. LOCAL_FUNC int NEAR
  577. menu_stereo (void)
  578. {
  579.     int     sel, quit, ch;
  580.     HMSG    *m;
  581.  
  582.     SetOption (0, 2);
  583.     sel = st.stereo;
  584.     for (quit = 0; !quit;) {
  585.         sel = menu_open (MenuStr, sel);
  586.         switch (sel) {
  587.         default:
  588.             quit = 1;
  589.             break;
  590.         case 0:
  591.         case 1:
  592.         case 2:
  593.             SetOption (0, sel);
  594.             break;
  595.         case 3:
  596.             sel = VIS_MONO;
  597.             goto set_stereo_mode;
  598.         case 4:
  599.             sel = VIS_STEREOSCOPIC;
  600.             goto set_stereo_mode;
  601.         case 5:
  602.             if (!Gr->SetWriteMode) {
  603.                 MsgPrintf (50, "Cannot do red/blue");
  604.                 break;
  605.             }
  606.             sel = VIS_REDBLUE;
  607.             goto set_stereo_mode;
  608.         case 6:
  609.             if (!Gr->Shutters || Gr->Shutters (-3)) {
  610.                 MsgPrintf (50, "No shutters");
  611.                 quit = 1;
  612.                 break;
  613.             }
  614.             sel = VIS_ALTERNATING;
  615.             goto set_stereo_mode;
  616. set_stereo_mode:
  617.             sim_set ();
  618.             show_fixed (1);
  619.             if (Gr->Shutters) {
  620.                 if (VIS_ALTERNATING == sel)
  621.                     Gr->Shutters (-1); /* shutters on */
  622.                 else
  623.                     Gr->Shutters (-2); /* shutters off */
  624.             }
  625.             if (VIS_STEREOSCOPIC == sel) {
  626.                 if (VIS_STEREOSCOPIC != st.stereo)
  627.                     set_small_frame ();
  628.             } else if (VIS_STEREOSCOPIC == st.stereo)
  629.                 set_large_frame ();
  630.             st.stereo = sel;
  631.             show_fixed (0);
  632.             sim_reset ();
  633.             quit = 1;
  634.             break;
  635.         case 7:
  636.             SetOption (&st.flags1, SF_STEREOREV);
  637.             break;
  638.         case 8:
  639.             for (;;) {
  640.                 if (F(m = MsgPrintf (0, "paralx(%d) ?[+-]",
  641.                             (int)st.paralax)))
  642.                     break;
  643.                 ch = mgetch ();
  644.                 m = msg_del (m);
  645.                 if ('+' == ch)
  646.                     ++st.paralax;
  647.                 else if ('-' == ch)
  648.                     --st.paralax;
  649.                 else if (KF_ESC == ch)
  650.                     break;
  651.             }
  652.             break;
  653.         }
  654.         if (MENU_FAILED != sel)
  655.             menu_close ();
  656.     }
  657.  
  658.     return (0);
  659. }
  660.  
  661. /* screen menu
  662. */
  663.  
  664. static MENU FAR MenuScr[] = {
  665.     {'0', "off"},        /*  0 */
  666.     {'1', "on"},        /*  1 */
  667.     {'2', "toggle"},    /*  2 */
  668.     {'p', "Palette"},    /*  3 */
  669.     {'c', "Colors"},    /*  4 */
  670.     {'s', "Stereo"},    /*  5 */
  671.     {'d', "Dbl Buff"},    /*  6 */
  672.     {'b', "Blanker"},    /*  7 */
  673.     {'h', "hudpos"},    /*  8 */
  674.     {'C', "clear"},        /*  9 */
  675. {'\0', 0}};
  676.  
  677. LOCAL_FUNC int NEAR
  678. menu_screen (void)
  679. {
  680.     int     sel, quit;
  681.     Ushort  temp;
  682.  
  683.     SetOption (0, 2);
  684.     sel = 0;
  685.     do {
  686.         quit = 1;
  687.         sel = menu_open (MenuScr, sel);
  688.         switch (sel) {
  689.         default:
  690.             break;
  691.         case 0:
  692.         case 1:
  693.         case 2:
  694.             SetOption (0, sel);
  695.             quit = 0;
  696.             break;
  697.         case 3:
  698.             menu_palette ();
  699.             break;
  700.         case 4:
  701.             menu_colors ();
  702.             break;
  703.         case 5:
  704.             menu_stereo ();
  705.             break;
  706.         case 6:
  707.             temp = st.flags1;
  708.             SetOption (&temp, SF_DBUFFERING);
  709.             if (temp != st.flags1)
  710.                 double_buffer (temp);
  711.             break;
  712.         case 7:
  713.             temp = st.flags;
  714.             SetOption (&temp, SF_BLANKER);
  715.             if (temp != st.flags) {
  716.                 sim_set ();
  717.                 if (st.flags & SF_BLANKER) {
  718.                     st.flags ^= SF_BLANKER;
  719.                     show_fixed (0);
  720.                 } else {
  721.                     show_fixed (1);
  722.                     st.flags ^= SF_BLANKER;
  723.                 }
  724.                 sim_reset ();
  725.             }
  726.             break;
  727.         case 8:
  728.             SetOption (&st.flags1, SF_HUDINFRONT);
  729.             break;
  730.         case 9:
  731.             sim_set ();
  732.             show_fixed (0);
  733.             sim_reset ();
  734.             break;
  735.         }
  736.         if (MENU_FAILED != sel)
  737.             menu_close ();
  738.     } while (!quit);
  739.  
  740.     return (0);
  741. }
  742.  
  743. /* autopilot menu
  744. */
  745.  
  746. static MENU FAR MenuAuto[] = {
  747.     {'0', "off"},
  748.     {'1', "on"},
  749.     {'2', "toggle"},
  750.     {'f', "Flaps"},        /*  3 */
  751.     {'e', "Elevators"},    /*  4 */
  752.     {'d', "Rudder"},    /*  5 */
  753. {'\0', 0}};
  754.  
  755. LOCAL_FUNC int NEAR
  756. menu_auto (void)
  757. {
  758.     int    sel, quit;
  759.  
  760.     if (!IS_PLANE(CV))
  761.         return (0);
  762.  
  763.     SetOption (0, 2);
  764.     sel = 0;
  765.     for (quit = 0; !quit;) {
  766.         sel = menu_open (MenuAuto, sel);
  767.         switch (sel) {
  768.         default:
  769.             quit = 1;
  770.             break;
  771.         case 0:
  772.         case 1:
  773.         case 2:
  774.             SetOption (0, sel);
  775.             break;
  776.         case 3:
  777.             SetOption (&EE(CV)->flags, PF_AUTOFLAP);
  778.             break;
  779.         case 4:
  780.             SetOption (&EE(CV)->flags, PF_AUTOELEVATOR);
  781.             break;
  782.         case 5:
  783.             SetOption (&EE(CV)->flags, PF_AUTORUDDER);
  784.             break;
  785.         }
  786.         if (MENU_FAILED != sel)
  787.             menu_close ();
  788.     }
  789.     return (0);
  790. }
  791.  
  792. /* Top menu
  793. */
  794.  
  795. static MENU FAR MenuTop[] = {
  796.     {'x', "Exit"},        /*  0 */
  797.     {'h', "Help"},        /*  1 */
  798.     {'p', "Pointer"},    /*  2 */
  799.     {'s', "Screen"},    /*  3 */
  800.     {'w', "Windows"},    /*  4 */
  801.     {'i', "Info"},        /*  5 */
  802.     {'e', "Emit"},        /*  6 */
  803.     {'u', "Hud"},        /*  7 */
  804.     {'n', "Net"},        /*  8 */
  805.     {'o', "Options"},    /*  9 */
  806.     {'a', "Auto"},        /* 10 */
  807.     {'d', "Debug"},     /* 11 */
  808.     {'b', "Buttons"},     /* 12 */
  809.     {'c', "Command"},     /* 13 */
  810. {'\0', 0}};
  811.  
  812. extern int FAR
  813. menu_top (void)
  814. {
  815.     int    sel, ret, i;
  816.     Ushort    list;
  817.  
  818.     if (st.flags & SF_VERBOSE) {
  819.         list = set_lists (0);
  820.         set_lists (SF_MODES);
  821.     }
  822.  
  823.     ret = 0;
  824.     sel = menu_open (MenuTop, 0);
  825.  
  826.     switch (sel) {
  827.     default:
  828.         break;
  829.     case 0:
  830.         if (MENU_FAILED != (i = menu_open (MenuYN, 1))) {
  831.             if (0 == i)    /* "Yes" */
  832.                 ret = 1;
  833.             menu_close ();
  834.         }
  835.         break;
  836.     case 1:
  837.         set_lists (SF_HELP);
  838.         break;
  839.     case 2:
  840.         menu_ptrs ();
  841.         break;
  842.     case 3:
  843.         menu_screen ();
  844.         break;
  845.     case 4:
  846.         menu_windows ();
  847.         break;
  848.     case 5:
  849.         menu_info ();
  850.         break;
  851.     case 6:
  852.         menu_emit ();
  853.         break;
  854.     case 7:
  855.         if (!IS_PLANE(CV))
  856.             break;
  857.         menu_hud ();
  858.         break;
  859.     case 8:
  860.         menu_net ();
  861.         break;
  862.     case 9:
  863.         menu_opts ();
  864.         break;
  865.     case 10:
  866.         menu_auto ();
  867.         break;
  868.     case 11:
  869.         menu_debug ();
  870.         break;
  871.     case 12:
  872.         menu_btn ();
  873.         break;
  874.     case 13:
  875.         ret = menu_cmd ();
  876.         break;
  877.     }
  878.     if (MENU_FAILED != sel)
  879.         menu_close ();
  880.  
  881.     if (st.flags & SF_VERBOSE)
  882.         set_lists (list);
  883.  
  884.     return (ret);
  885. }
  886.